/**
 * ApiClient - 前端API客户端
 * 用于处理与后端服务器的所有HTTP通信
 */
(function() {
    // API基础URL，根据实际部署环境修改
    const BASE_URL = 'http://localhost:3000/api'; // 修改为新的API路径
    
    // 设置为false使用实际后端API，设为true使用模拟数据
    const USE_MOCK_API = false; // 修改为使用实际API
    
    // 将模拟API设置暴露给全局，方便调试
    window.USE_MOCK_API = USE_MOCK_API;
    
    // 向控制台输出API初始化信息（调试用）
    console.log('API Client initialized with BASE_URL:', BASE_URL);
    console.log('API模式:', USE_MOCK_API ? '模拟API' : '实际API');
    
    // 添加一个通知，告知用户系统正在使用模拟数据
    setTimeout(() => {
        if (window.showNotification && USE_MOCK_API) {
            window.showNotification('系统正在使用模拟数据，所有功能正常，但数据将存储在本地', 'info', 5000);
        }
    }, 1000);
    
    /**
     * 通用请求函数
     * @param {string} endpoint - API端点
     * @param {string} method - HTTP方法
     * @param {Object} data - 请求数据
     * @param {boolean} requiresAuth - 是否需要认证
     * @returns {Promise<Object>} - 返回API响应
     */
    async function request(endpoint, method = 'GET', data = null, requiresAuth = false) {
        const url = `${BASE_URL}${endpoint}`;
        
        // 准备请求头
        const headers = {
            'Content-Type': 'application/json'
        };
        
        // 如果需要认证，添加token
        if (requiresAuth) {
            const token = localStorage.getItem('auth_token');
            if (!token) {
                throw new Error('需要登录');
            }
            headers['Authorization'] = `Bearer ${token}`;
        }
        
        // 准备请求选项
        const options = {
            method,
            headers,
            credentials: 'include', // 包含cookies
        };
        
        // 对于GET请求，将数据转换为查询参数
        if (method === 'GET' && data) {
            const params = new URLSearchParams();
            for (const key in data) {
                params.append(key, data[key]);
            }
            endpoint += `?${params.toString()}`;
        } else if (data) {
            // 对于其他请求方法，将数据放入请求体
            options.body = JSON.stringify(data);
        }
        
        try {
            // 发送请求
            const response = await fetch(url, options);
            
            // 检查HTTP状态码
            if (!response.ok) {
                // 尝试解析错误详情
                let errorData;
                try {
                    errorData = await response.json();
                } catch (e) {
                    throw new Error(`服务器错误: ${response.status} ${response.statusText}`);
                }
                
                throw new Error(errorData.message || `请求失败: ${response.status} ${response.statusText}`);
            }
            
            // 解析响应数据
            return await response.json();
        } catch (error) {
            console.error('API请求失败:', error);
            throw error;
        }
    }
    
    // 模拟API响应（仅用于开发阶段，实际使用时请注释或删除此函数）
    function mockApiResponse(endpoint, method, data) {
        console.log(`[Mock API] ${method} ${endpoint}`, data);
        
        // 模拟延迟
        return new Promise(resolve => {
            setTimeout(() => {
                // 根据不同的端点返回不同的模拟数据
                switch (`${method} ${endpoint}`) {
                    case 'POST /auth/login':
                        resolve({
                            success: true,
                            token: 'mock_jwt_token_' + Date.now(),
                            user: {
                                id: 1,
                                username: data.username || '用户',
                                email: 'user@example.com',
                                avatar: 'https://via.placeholder.com/50'
                            }
                        });
                        break;
                        
                    case 'POST /auth/register':
                        resolve({
                            success: true,
                            message: '注册成功'
                        });
                        break;
                        
                    case 'GET /games':
                        resolve({
                            success: true,
                            games: [
                                {
                                    id: 1,
                                    title: '冒险岛',
                                    category: '冒险',
                                    thumbnail: 'https://via.placeholder.com/150',
                                    downloads: 1200,
                                    rating: 4.5,
                                    created_at: '2023-07-15'
                                },
                                {
                                    id: 2,
                                    title: '消消乐',
                                    category: '休闲',
                                    thumbnail: 'https://via.placeholder.com/150',
                                    downloads: 2500,
                                    rating: 4.8,
                                    created_at: '2023-08-20'
                                }
                            ],
                            total: 2,
                            page: 1,
                            per_page: 10
                        });
                        break;
                        
                    case 'POST /games':
                    case 'POST /games/upload': // 添加与后端匹配的路径
                        resolve({
                            success: true,
                            game_id: Date.now(),
                            message: '游戏上传成功'
                        });
                        break;
                        
                    default:
                        resolve({
                            success: false,
                            message: '未实现的模拟端点'
                        });
                }
            }, 500); // 模拟网络延迟
        });
    }
    
    // 实际的请求函数，根据配置决定是否使用模拟数据
    async function makeRequest(endpoint, method, data, requiresAuth) {
        console.log(`Making ${method} request to ${endpoint}`, data);
        
        if (USE_MOCK_API) {
            console.log('Using mock API mode');
            return mockApiResponse(endpoint, method, data);
        } else {
            try {
                return await request(endpoint, method, data, requiresAuth);
            } catch (error) {
                console.error(`API request failed: ${method} ${endpoint}`, error);
                // 将错误重新抛出以便上层处理
                throw error;
            }
        }
    }
    
    /**
     * API客户端对象
     */
    const ApiClient = {
        /**
         * 用户相关API
         */
        User: {
            /**
             * 用户登录
             * @param {string} username - 用户名
             * @param {string} password - 密码
             * @returns {Promise<Object>} - 登录结果
             */
            login: async function(username, password) {
                return await makeRequest('/auth/login', 'POST', { username, password });
            },
            
            /**
             * 用户注册
             * @param {Object} userData - 用户数据
             * @returns {Promise<Object>} - 注册结果
             */
            register: async function(userData) {
                return await makeRequest('/auth/register', 'POST', userData);
            },
            
            /**
             * 退出登录
             */
            logout: function() {
                localStorage.removeItem('auth_token');
                localStorage.removeItem('user_info');
                console.log('用户已退出登录');
                return true;
            },
            
            /**
             * 检查用户是否已登录
             * @returns {boolean} - 是否已登录
             */
            isLoggedIn: function() {
                return !!localStorage.getItem('auth_token');
            },
            
            /**
             * 获取当前用户信息
             * @returns {Promise<Object>} - 用户信息
             */
            getCurrentUser: async function() {
                return await makeRequest('/users/me', 'GET', null, true);
            },
            
            /**
             * 更新用户信息
             * @param {Object} userData - 用户数据
             * @returns {Promise<Object>} - 更新结果
             */
            updateProfile: async function(userData) {
                return await makeRequest('/users/me', 'PUT', userData, true);
            },
            
            /**
             * 修改密码
             * @param {string} currentPassword - 当前密码
             * @param {string} newPassword - 新密码
             * @returns {Promise<Object>} - 修改结果
             */
            changePassword: async function(currentPassword, newPassword) {
                return await makeRequest('/users/me/password', 'PUT', {
                    current_password: currentPassword,
                    new_password: newPassword
                }, true);
            }
        },
        
        /**
         * 游戏相关API
         */
        Games: {
            /**
             * 获取游戏列表
             * @param {Object} params - 查询参数
             * @returns {Promise<Object>} - 游戏列表
             */
            getGames: async function(params = {}) {
                return await makeRequest('/games', 'GET', params);
            },
            
            /**
             * 获取热门游戏
             * @param {number} limit - 限制数量
             * @returns {Promise<Object>} - 热门游戏列表
             */
            getHotGames: async function(limit = 10) {
                return await makeRequest('/games/hot', 'GET', { limit });
            },
            
            /**
             * 获取游戏详情
             * @param {number} gameId - 游戏ID
             * @returns {Promise<Object>} - 游戏详情
             */
            getGameDetails: async function(gameId) {
                return await makeRequest(`/games/${gameId}`, 'GET');
            },
            
            /**
             * 上传游戏
             * @param {Object} gameData - 游戏数据
             * @param {File} gameFile - 游戏文件
             * @param {File} thumbnailFile - 缩略图文件
             * @param {Function} progressCallback - 上传进度回调函数
             * @returns {Promise<Object>} - 上传结果
             */
            uploadGame: async function(gameData, gameFile, thumbnailFile, progressCallback) {
                // 使用FormData处理文件上传
                const formData = new FormData();
                
                // 添加游戏数据
                formData.append('title', gameData.title);
                formData.append('category', gameData.category);
                formData.append('description', gameData.description);
                
                // 添加文件
                if (gameFile) formData.append('gameFile', gameFile);
                if (thumbnailFile) formData.append('thumbnail', thumbnailFile);
                
                console.log('游戏上传开始，数据:', gameData);
                console.log('文件信息:', gameFile ? `游戏文件: ${gameFile.name}` : '无游戏文件', 
                            thumbnailFile ? `缩略图: ${thumbnailFile.name}` : '无缩略图');
                
                // 如果使用模拟API，直接返回模拟响应
                if (USE_MOCK_API) {
                    console.log('使用模拟API上传，您将在几秒钟内看到上传"成功"');
                    
                    // 模拟上传进度
                    if (progressCallback && typeof progressCallback === 'function') {
                        let progress = 0;
                        const interval = setInterval(() => {
                            progress += 10;
                            progressCallback(progress);
                            if (progress >= 100) {
                                clearInterval(interval);
                            }
                        }, 300);
                    }
                    
                    // 返回模拟响应
                    return new Promise(resolve => {
                        setTimeout(() => {
                            const mockGameId = Date.now();
                            const mockFilePath = `uploads/games/game_${mockGameId}.${gameFile ? gameFile.name.split('.').pop() : 'zip'}`;
                            const mockThumbnailPath = `uploads/thumbnails/thumb_${mockGameId}.${thumbnailFile ? thumbnailFile.name.split('.').pop() : 'jpg'}`;
                            
                            console.log(`模拟游戏上传成功, 游戏ID: ${mockGameId}`);
                            
                            if (window.showNotification) {
                                window.showNotification('游戏上传成功！', 'success');
                            }
                            
                            resolve({
                                success: true,
                                game_id: mockGameId,
                                message: '游戏上传成功',
                                game: {
                                    id: mockGameId,
                                    title: gameData.title,
                                    category: gameData.category,
                                    description: gameData.description,
                                    filePath: mockFilePath,
                                    thumbnail: mockThumbnailPath,
                                    status: 'pending',
                                    plays: 0,
                                    downloads: 0,
                                    rating: 0,
                                    createdAt: new Date().toISOString()
                                }
                            });
                        }, 3000);
                    });
                }
                
                // 准备请求头
                const headers = {};
                
                // 如果需要认证，添加token
                const token = localStorage.getItem('auth_token');
                if (!token) {
                    throw new Error('需要登录');
                }
                headers['Authorization'] = `Bearer ${token}`;
                
                // 使用XMLHttpRequest实现进度监控
                return new Promise((resolve, reject) => {
                    const xhr = new XMLHttpRequest();
                    
                    // 监听上传进度
                    if (progressCallback && typeof progressCallback === 'function') {
                        xhr.upload.addEventListener('progress', (event) => {
                            if (event.lengthComputable) {
                                const percentComplete = Math.round((event.loaded / event.total) * 100);
                                progressCallback(percentComplete);
                            }
                        });
                    }
                    
                    // 处理请求完成
                    xhr.onload = function() {
                        if (xhr.status >= 200 && xhr.status < 300) {
                            try {
                                const response = JSON.parse(xhr.responseText);
                                resolve(response);
                            } catch (e) {
                                reject(new Error('解析响应失败'));
                            }
                        } else {
                            try {
                                const errorData = JSON.parse(xhr.responseText);
                                reject(new Error(errorData.message || `请求失败: ${xhr.status} ${xhr.statusText}`));
                            } catch (e) {
                                reject(new Error(`服务器错误: ${xhr.status} ${xhr.statusText}`));
                            }
                        }
                    };
                    
                    // 处理请求错误
                    xhr.onerror = function() {
                        reject(new Error('网络错误，请检查您的连接'));
                    };
                    
                    // 打开请求
                    xhr.open('POST', `${BASE_URL}/games/upload`, true); // 修改为与后端匹配的路径
                    
                    // 添加请求头
                    for (const key in headers) {
                        xhr.setRequestHeader(key, headers[key]);
                    }
                    
                    // 发送请求
                    xhr.send(formData);
                });
            },
            
            /**
             * 更新游戏信息
             * @param {number} gameId - 游戏ID
             * @param {Object} gameData - 游戏数据
             * @returns {Promise<Object>} - 更新结果
             */
            updateGame: async function(gameId, gameData) {
                return await makeRequest(`/games/${gameId}`, 'PUT', gameData, true);
            },
            
            /**
             * 删除游戏
             * @param {number} gameId - 游戏ID
             * @returns {Promise<Object>} - 删除结果
             */
            deleteGame: async function(gameId) {
                return await makeRequest(`/games/${gameId}`, 'DELETE', null, true);
            },
            
            /**
             * 获取用户上传的游戏
             * @returns {Promise<Object>} - 用户游戏列表
             */
            getUserGames: async function() {
                return await makeRequest('/users/me/games', 'GET', null, true);
            }
        },
        
        /**
         * 评论相关API
         */
        Comments: {
            /**
             * 获取游戏评论
             * @param {number} gameId - 游戏ID
             * @param {Object} params - 查询参数
             * @returns {Promise<Object>} - 评论列表
             */
            getComments: async function(gameId, params = {}) {
                return await makeRequest(`/games/${gameId}/comments`, 'GET', params);
            },
            
            /**
             * 添加评论
             * @param {number} gameId - 游戏ID
             * @param {string} content - 评论内容
             * @param {number} rating - 评分
             * @returns {Promise<Object>} - 添加结果
             */
            addComment: async function(gameId, content, rating) {
                return await makeRequest(`/games/${gameId}/comments`, 'POST', {
                    content,
                    rating
                }, true);
            },
            
            /**
             * 删除评论
             * @param {number} commentId - 评论ID
             * @returns {Promise<Object>} - 删除结果
             */
            deleteComment: async function(commentId) {
                return await makeRequest(`/comments/${commentId}`, 'DELETE', null, true);
            }
        },
        
        /**
         * 搜索相关API
         */
        Search: {
            /**
             * 搜索游戏
             * @param {string} query - 搜索关键词
             * @param {Object} filters - 过滤条件
             * @returns {Promise<Object>} - 搜索结果
             */
            searchGames: async function(query, filters = {}) {
                return await makeRequest('/search/games', 'GET', {
                    q: query,
                    ...filters
                });
            }
        }
    };
    
    // 将API客户端暴露给全局
    window.ApiClient = ApiClient;
})(); 